TypeScript: Überprüfung auf überschüssige Eigenschaften – Stärkung Ihrer Objekt-Typsicherheit

            
interface User {
  name: string;
  age: number;
}

const newUser: User = {
  name: 'Alice',
  age: 30,
  email: 'alice@example.com' // Fehler: Objektliteral darf nur bekannte Eigenschaften angeben, und 'email' ist im Typ 'User' nicht vorhanden.
};

            

              
                Copy
              
            
          

            
interface Product {
  id: number;
  name: string;
}

function displayProduct(product: Product): void {
  console.log(`Product ID: ${product.id}, Name: ${product.name}`);
}

displayProduct({
  id: 101,
  name: 'Laptop',
  price: 1200 // Fehler: Argument des Typs '{ id: number; name: string; price: number; }' kann dem Parameter des Typs 'Product' nicht zugewiesen werden.
             // Objektliteral darf nur bekannte Eigenschaften angeben, und 'price' ist im Typ 'Product' nicht vorhanden.
});

            

              
                Copy
              
            
          

            
interface Config {
  timeout: number;
}

function setupConfig(config: Config) {
  console.log(`Timeout set to: ${config.timeout}`);
}

const userProvidedConfig = {
  timeout: 5000,
  retries: 3 // Diese 'retries'-Eigenschaft ist gemäß 'Config' eine überschüssige Eigenschaft
};

setupConfig(userProvidedConfig); // Kein Fehler!

// Obwohl userProvidedConfig eine zusätzliche Eigenschaft hat, wird die Überprüfung übersprungen,
// da es sich nicht um ein direkt übergebenes Objektliteral handelt.
// TypeScript prüft den Typ von userProvidedConfig selbst.
// Wenn userProvidedConfig mit dem Typ Config deklariert worden wäre, würde ein Fehler früher auftreten.
// Wenn es jedoch als 'any' oder ein breiterer Typ deklariert ist, wird der Fehler aufgeschoben.

// Eine genauere Darstellung der Umgehung:
let anotherConfig;

if (Math.random() > 0.5) {
  anotherConfig = {
    timeout: 1000,
    host: 'localhost' // Überschüssige Eigenschaft
  };
} else {
  anotherConfig = {
    timeout: 2000,
    port: 8080 // Überschüssige Eigenschaft
  };
}

setupConfig(anotherConfig as Config); // Kein Fehler aufgrund der Typ-Zusicherung und Umgehung

// Der Schlüssel ist, dass 'anotherConfig' zum Zeitpunkt der Zuweisung an setupConfig kein Objektliteral ist.
// Hätten wir eine Zwischenvariable vom Typ 'Config', würde die anfängliche Zuweisung fehlschlagen.

// Beispiel für eine Zwischenvariable:
let intermediateConfig: Config;

intermediateConfig = {
  timeout: 3000,
  logging: true // Fehler: Objektliteral darf nur bekannte Eigenschaften angeben, und 'logging' ist im Typ 'Config' nicht vorhanden.
};

            

              
                Copy
              
            
          

            
interface Settings {
  theme: 'dark' | 'light';
}

const mySettings = {
  theme: 'dark',
  fontSize: 14 // Überschüssige Eigenschaft
} as Settings;

// Kein Fehler hier wegen der Typ-Zusicherung.
// Wir sagen TypeScript: "Vertrau mir, dieses Objekt entspricht Settings."
console.log(mySettings.theme);
// console.log(mySettings.fontSize); // Dies würde einen Laufzeitfehler verursachen, wenn fontSize nicht tatsächlich vorhanden wäre.

            

              
                Copy
              
            
          

            
interface FlexibleObject {
  id: number;
  [key: string]: any; // Erlaubt jeden String-Schlüssel mit beliebigem Wert
}

const flexibleItem: FlexibleObject = {
  id: 1,
  name: 'Widget',
  version: '1.0.0'
};

// Kein Fehler, da 'name' und 'version' durch die Index-Signatur erlaubt sind.
console.log(flexibleItem.name);

            

              
                Copy
              
            
          

            
interface BaseConfig {
  host: string;
}

interface ExtendedConfig extends BaseConfig {
  port: number;
}

const defaultConfig: BaseConfig = {
  host: 'localhost'
};

const userConfig = {
  port: 8080,
  timeout: 5000 // Überschüssige Eigenschaft im Verhältnis zu BaseConfig, aber vom zusammengeführten Typ erwartet
};

// Spreading in ein neues Objektliteral, das mit ExtendedConfig konform ist
const finalConfig: ExtendedConfig = {
  ...defaultConfig,
  ...userConfig
};

// Dies ist im Allgemeinen in Ordnung, da 'finalConfig' als 'ExtendedConfig' deklariert ist
// und die Eigenschaften übereinstimmen. Die Prüfung erfolgt auf dem Typ von 'finalConfig'.

// Betrachten wir ein Szenario, in dem es fehlschlagen *würde*:

interface SmallConfig {
  key: string;
}

const data1 = { key: 'abc', value: 123 }; // 'value' ist hier zusätzlich
const data2 = { key: 'xyz', status: 'active' }; // 'status' ist hier zusätzlich

// Versuch der Zuweisung an einen Typ, der keine Extras berücksichtigt

// const combined: SmallConfig = {
//   ...data1, // Fehler: Objektliteral darf nur bekannte Eigenschaften angeben, und 'value' ist im Typ 'SmallConfig' nicht vorhanden.
//   ...data2  // Fehler: Objektliteral darf nur bekannte Eigenschaften angeben, und 'status' ist im Typ 'SmallConfig' nicht vorhanden.
// };

// Der Fehler tritt auf, weil das durch die Spread-Syntax gebildete Objektliteral
// Eigenschaften ('value', 'status') enthält, die in 'SmallConfig' nicht vorhanden sind.

// Wenn wir eine Zwischenvariable mit einem breiteren Typ erstellen:

const temp: any = {
  ...data1,
  ...data2
};

// Dann bei der Zuweisung an SmallConfig wird die Überprüfung auf überschüssige Eigenschaften bei der Erstellung des initialen Literals umgangen,
// aber die Typprüfung bei der Zuweisung könnte immer noch stattfinden, wenn der Typ von temp strenger inferiert wird.
// Wenn temp jedoch 'any' ist, findet bis zur Zuweisung an 'combined' keine Prüfung statt.

// Verfeinern wir das Verständnis von Spread mit Überprüfungen auf überschüssige Eigenschaften:
// Die Überprüfung findet statt, wenn das durch die Spread-Syntax erstellte Objektliteral
// einer Variablen zugewiesen oder an eine Funktion übergeben wird, die einen spezifischeren Typ erwartet.

interface SpecificShape { 
  id: number;
}

const objA = { id: 1, extra1: 'hello' };
const objB = { id: 2, extra2: 'world' };

// Dies wird fehlschlagen, wenn SpecificShape 'extra1' oder 'extra2' nicht zulässt:
// const merged: SpecificShape = {
//   ...objA,
//   ...objB
// };

// Der Grund für den Fehler ist, dass die Spread-Syntax effektiv ein neues Objektliteral erstellt.
// Wenn objA und objB überlappende Schlüssel hätten, würde der spätere gewinnen. Der Compiler
// sieht dieses resultierende Literal und prüft es gegen 'SpecificShape'.

// Um es zum Laufen zu bringen, benötigen Sie möglicherweise einen Zwischenschritt oder einen nachsichtigeren Typ:

const tempObj = {
  ...objA,
  ...objB
};

// Wenn tempObj nun Eigenschaften hat, die nicht in SpecificShape enthalten sind, wird die Zuweisung fehlschlagen:
// const mergedCorrected: SpecificShape = tempObj; // Fehler: Objektliteral darf nur bekannte Eigenschaften angeben...

// Der Schlüssel ist, dass der Compiler die Form des zu bildenden Objektliterals analysiert.
// Wenn dieses Literal Eigenschaften enthält, die nicht im Zieltyp definiert sind, ist es ein Fehler.

// Der typische Anwendungsfall für die Spread-Syntax mit Überprüfungen auf überschüssige Eigenschaften:

interface UserProfile {
  userId: string;
  username: string;
}

interface AdminProfile extends UserProfile {
  adminLevel: number;
}

const baseUserData: UserProfile = {
  userId: 'user-123',
  username: 'coder'
};

const adminData = {
  adminLevel: 5,
  lastLogin: '2023-10-27'
};

// Hier ist die Überprüfung auf überschüssige Eigenschaften relevant:
// const adminProfile: AdminProfile = {
//   ...baseUserData,
//   ...adminData // Fehler: Objektliteral darf nur bekannte Eigenschaften angeben, und 'lastLogin' ist im Typ 'AdminProfile' nicht vorhanden.
// };

// Das durch den Spread erstellte Objektliteral hat 'lastLogin', was nicht in 'AdminProfile' enthalten ist.
// Um dies zu beheben, sollte 'adminData' idealerweise mit AdminProfile konform sein oder die überschüssige Eigenschaft sollte behandelt werden.

// Korrigierter Ansatz:
const validAdminData = {
  adminLevel: 5
};

const adminProfileCorrect: AdminProfile = {
  ...baseUserData,
  ...validAdminData
};

console.log(adminProfileCorrect.userId);
console.log(adminProfileCorrect.adminLevel);

            

              
                Copy
              
            
          

            
interface UserProfile {
  id: number;
  name: string;
}

interface UserWithMetadata extends UserProfile {
  metadata: {
    [key: string]: any;
  };
}

// Oder häufiger mit einem Typ-Alias und der Rest-Syntax:
type UserProfileWithMetadata = UserProfile & {
  [key: string]: any;
};

const user1: UserProfileWithMetadata = {
  id: 1,
  name: 'Bob',
  email: 'bob@example.com',
  isAdmin: true
};

// Kein Fehler, da 'email' und 'isAdmin' von der Index-Signatur in UserProfileWithMetadata erfasst werden.
console.log(user1.email);
console.log(user1.isAdmin);

// Eine andere Möglichkeit unter Verwendung von Rest-Parametern in einer Typdefinition:
interface ConfigWithRest {
  apiUrl: string;
  timeout?: number;
  // Erfasse alle anderen Eigenschaften in 'extraConfig'
  [key: string]: any;
}

const appConfig: ConfigWithRest = {
  apiUrl: 'https://api.example.com',
  timeout: 5000,
  featureFlags: {
    newUI: true,
    betaFeatures: false
  }
};

console.log(appConfig.featureFlags);

            

              
                Copy
              
            
          

            
interface Employee {
  employeeId: string;
  department: string;
}

function processEmployeeData(data: Employee & { [key: string]: any }) {
  const { employeeId, department, ...otherDetails } = data;

  console.log(`Employee ID: ${employeeId}`);
  console.log(`Department: ${department}`);
  console.log('Other details:', otherDetails);
  // otherDetails enthält alle Eigenschaften, die nicht explizit destrukturiert wurden,
  // wie 'salary', 'startDate' usw.
}

const employeeInfo = {
  employeeId: 'emp-789',
  department: 'Engineering',
  salary: 90000,
  startDate: '2022-01-15'
};

processEmployeeData(employeeInfo);

// Selbst wenn employeeInfo anfangs eine zusätzliche Eigenschaft hatte, wird die Überprüfung auf überschüssige Eigenschaften
// umgangen, wenn die Funktionssignatur dies akzeptiert (z. B. durch Verwendung einer Index-Signatur).
// Wäre processEmployeeData streng als 'Employee' typisiert und hätte employeeInfo 'salary',
// würde ein Fehler auftreten, WENN employeeInfo ein direkt übergebenes Objektliteral wäre.
// Aber hier ist employeeInfo eine Variable, und der Typ der Funktion behandelt Extras.

            

              
                Copy
              
            
          

            
interface UserProfile {
  id: number;
  name: string;
  email?: string; // Optionale E-Mail
}

const userWithEmail: UserProfile = {
  id: 2,
  name: 'Charlie',
  email: 'charlie@example.com'
};

const userWithoutEmail: UserProfile = {
  id: 3,
  name: 'David'
};

// Wenn wir versuchen, eine Eigenschaft hinzuzufügen, die nicht in UserProfile ist:
// const userWithExtra: UserProfile = {
//   id: 4,
//   name: 'Eve',
//   phoneNumber: '555-1234'
// }; // Fehler: Objektliteral darf nur bekannte Eigenschaften angeben, und 'phoneNumber' ist im Typ 'UserProfile' nicht vorhanden.

            

              
                Copy
              
            
          

            
interface ProductConfig {
  id: string;
  version: string;
}

// Stellen Sie sich vor, dies kommt von einer externen Quelle oder einem weniger strengen Modul
const externalConfig = {
  id: 'prod-abc',
  version: '1.2',
  debugMode: true // Überschüssige Eigenschaft
};

// Wenn Sie wissen, dass 'externalConfig' immer 'id' und 'version' haben wird und Sie es als ProductConfig behandeln möchten:
const productConfig = externalConfig as ProductConfig;

// Diese Zusicherung umgeht die Überprüfung auf überschüssige Eigenschaften für `externalConfig` selbst.
// Wenn Sie jedoch ein Objektliteral direkt übergeben würden:

// const productConfigLiteral: ProductConfig = {
//   id: 'prod-xyz',
//   version: '2.0',
//   debugMode: false
// }; // Fehler: Objektliteral darf nur bekannte Eigenschaften angeben, und 'debugMode' ist im Typ 'ProductConfig' nicht vorhanden.

            

              
                Copy
              
            
          

            
interface Shape {
  kind: 'circle' | 'square';
}

interface Circle extends Shape {
  kind: 'circle';
  radius: number;
}

interface Square extends Shape {
  kind: 'square';
  sideLength: number;
}

function calculateArea(shape: Shape) {
  if (shape.kind === 'circle') {
    // TypeScript weiß hier, dass 'shape' ein Circle ist
    console.log(Math.PI * shape.radius ** 2);
  } else if (shape.kind === 'square') {
    // TypeScript weiß hier, dass 'shape' ein Square ist
    console.log(shape.sideLength ** 2);
  }
}

const circleData = {
  kind: 'circle' as const, // Verwendung von 'as const' für die Inferenz des literalen Typs
  radius: 10,
  color: 'red' // Überschüssige Eigenschaft
};

// Bei der Übergabe an calculateArea erwartet die Funktionssignatur 'Shape'.
// Die Funktion selbst wird korrekt auf 'kind' zugreifen.
// Wenn calculateArea direkt 'Circle' erwarten und circleData
// als Objektliteral erhalten würde, wäre 'color' ein Problem.

// Veranschaulichen wir die Überprüfung auf überschüssige Eigenschaften mit einer Funktion, die einen spezifischen Untertyp erwartet:

function processCircle(circle: Circle) {
  console.log(`Processing circle with radius: ${circle.radius}`);
}

// processCircle(circleData); // Fehler: Argument des Typs '{ kind: "circle"; radius: number; color: string; }' kann dem Parameter des Typs 'Circle' nicht zugewiesen werden.
                         // Objektliteral darf nur bekannte Eigenschaften angeben, und 'color' ist im Typ 'Circle' nicht vorhanden.

// Um dies zu beheben, können Sie destrukturieren oder einen nachsichtigeren Typ für circleData verwenden:

const { color, ...circleDataWithoutColor } = circleData;
processCircle(circleDataWithoutColor);

// Oder definieren Sie circleData so, dass es einen breiteren Typ einschließt:

const circleDataWithExtras: Circle & { [key: string]: any } = {
  kind: 'circle',
  radius: 15,
  color: 'blue'
};
processCircle(circleDataWithExtras); // Jetzt funktioniert es.

            

              
                Copy